home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / compiler / pyassem.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  23KB  |  842 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import dis
  5. import new
  6. import sys
  7. from compiler import misc
  8. from compiler.consts import CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS
  9.  
  10. class FlowGraph:
  11.     
  12.     def __init__(self):
  13.         self.current = self.entry = Block()
  14.         self.exit = Block('exit')
  15.         self.blocks = misc.Set()
  16.         self.blocks.add(self.entry)
  17.         self.blocks.add(self.exit)
  18.  
  19.     
  20.     def startBlock(self, block):
  21.         if self._debug:
  22.             if self.current:
  23.                 print 'end', repr(self.current)
  24.                 print '    next', self.current.next
  25.                 print '   ', self.current.get_children()
  26.             
  27.             print repr(block)
  28.         
  29.         self.current = block
  30.  
  31.     
  32.     def nextBlock(self, block = None):
  33.         if block is None:
  34.             block = self.newBlock()
  35.         
  36.         self.current.addNext(block)
  37.         self.startBlock(block)
  38.  
  39.     
  40.     def newBlock(self):
  41.         b = Block()
  42.         self.blocks.add(b)
  43.         return b
  44.  
  45.     
  46.     def startExitBlock(self):
  47.         self.startBlock(self.exit)
  48.  
  49.     _debug = 0
  50.     
  51.     def _enable_debug(self):
  52.         self._debug = 1
  53.  
  54.     
  55.     def _disable_debug(self):
  56.         self._debug = 0
  57.  
  58.     
  59.     def emit(self, *inst):
  60.         if self._debug:
  61.             print '\t', inst
  62.         
  63.         if inst[0] in ('RETURN_VALUE', 'YIELD_VALUE'):
  64.             self.current.addOutEdge(self.exit)
  65.         
  66.         if len(inst) == 2 and isinstance(inst[1], Block):
  67.             self.current.addOutEdge(inst[1])
  68.         
  69.         self.current.emit(inst)
  70.  
  71.     
  72.     def getBlocksInOrder(self):
  73.         for b in self.blocks.elements():
  74.             if b is self.exit:
  75.                 continue
  76.             
  77.             if not b.next:
  78.                 b.addNext(self.exit)
  79.                 continue
  80.         
  81.         order = dfs_postorder(self.entry, { })
  82.         order.reverse()
  83.         self.fixupOrder(order, self.exit)
  84.         if self.exit not in order:
  85.             order.append(self.exit)
  86.         
  87.         return order
  88.  
  89.     
  90.     def fixupOrder(self, blocks, default_next):
  91.         self.fixupOrderHonorNext(blocks, default_next)
  92.         self.fixupOrderForward(blocks, default_next)
  93.  
  94.     
  95.     def fixupOrderHonorNext(self, blocks, default_next):
  96.         index = { }
  97.         for i in range(len(blocks)):
  98.             index[blocks[i]] = i
  99.         
  100.         for i in range(0, len(blocks) - 1):
  101.             b = blocks[i]
  102.             n = blocks[i + 1]
  103.             if not (b.next) and b.next[0] == default_next or b.next[0] == n:
  104.                 continue
  105.             
  106.             cur = b
  107.             chain = []
  108.             elt = cur
  109.             while elt.next and elt.next[0] != default_next:
  110.                 chain.append(elt.next[0])
  111.                 elt = elt.next[0]
  112.             l = []
  113.             for b in chain:
  114.                 l.append((index[b], b))
  115.             
  116.             l.sort()
  117.             l.reverse()
  118.             for j, b in l:
  119.                 del blocks[index[b]]
  120.             
  121.             blocks[i:i + 1] = [
  122.                 cur] + chain
  123.             for i in range(len(blocks)):
  124.                 index[blocks[i]] = i
  125.             
  126.         
  127.  
  128.     
  129.     def fixupOrderForward(self, blocks, default_next):
  130.         index = { }
  131.         chains = []
  132.         cur = []
  133.         for b in blocks:
  134.             index[b] = len(chains)
  135.             cur.append(b)
  136.             if b.next and b.next[0] == default_next:
  137.                 chains.append(cur)
  138.                 cur = []
  139.                 continue
  140.         
  141.         chains.append(cur)
  142.         while None:
  143.             constraints = []
  144.             for i in range(len(chains)):
  145.                 l = chains[i]
  146.                 for b in l:
  147.                     for c in b.get_children():
  148.                         if index[c] < i:
  149.                             forward_p = 0
  150.                             for inst in b.insts:
  151.                                 if inst[0] == 'JUMP_FORWARD':
  152.                                     if inst[1] == c:
  153.                                         forward_p = 1
  154.                                     
  155.                                 inst[1] == c
  156.                             
  157.                             if not forward_p:
  158.                                 continue
  159.                             
  160.                             constraints.append((index[c], i))
  161.                             continue
  162.                     
  163.                 
  164.             
  165.             if not constraints:
  166.                 break
  167.             
  168.             (goes_before, a_chain) = constraints[0]
  169.             c = chains[a_chain]
  170.             chains.insert(goes_before, c)
  171.             continue
  172.             del blocks[:]
  173.             for c in chains:
  174.                 for b in c:
  175.                     blocks.append(b)
  176.                 
  177.             
  178.  
  179.     
  180.     def getBlocks(self):
  181.         return self.blocks.elements()
  182.  
  183.     
  184.     def getRoot(self):
  185.         return self.entry
  186.  
  187.     
  188.     def getContainedGraphs(self):
  189.         l = []
  190.         for b in self.getBlocks():
  191.             l.extend(b.getContainedGraphs())
  192.         
  193.         return l
  194.  
  195.  
  196.  
  197. def dfs_postorder(b, seen):
  198.     order = []
  199.     seen[b] = b
  200.     for c in b.get_children():
  201.         if seen.has_key(c):
  202.             continue
  203.         
  204.         order = order + dfs_postorder(c, seen)
  205.     
  206.     order.append(b)
  207.     return order
  208.  
  209.  
  210. class Block:
  211.     _count = 0
  212.     
  213.     def __init__(self, label = ''):
  214.         self.insts = []
  215.         self.inEdges = misc.Set()
  216.         self.outEdges = misc.Set()
  217.         self.label = label
  218.         self.bid = Block._count
  219.         self.next = []
  220.         Block._count = Block._count + 1
  221.  
  222.     
  223.     def __repr__(self):
  224.         if self.label:
  225.             return '<block %s id=%d>' % (self.label, self.bid)
  226.         else:
  227.             return '<block id=%d>' % self.bid
  228.  
  229.     
  230.     def __str__(self):
  231.         insts = map(str, self.insts)
  232.         return '<block %s %d:\n%s>' % (self.label, self.bid, '\n'.join(insts))
  233.  
  234.     
  235.     def emit(self, inst):
  236.         op = inst[0]
  237.         if op[:4] == 'JUMP':
  238.             self.outEdges.add(inst[1])
  239.         
  240.         self.insts.append(inst)
  241.  
  242.     
  243.     def getInstructions(self):
  244.         return self.insts
  245.  
  246.     
  247.     def addInEdge(self, block):
  248.         self.inEdges.add(block)
  249.  
  250.     
  251.     def addOutEdge(self, block):
  252.         self.outEdges.add(block)
  253.  
  254.     
  255.     def addNext(self, block):
  256.         self.next.append(block)
  257.  
  258.     _uncond_transfer = ('RETURN_VALUE', 'RAISE_VARARGS', 'YIELD_VALUE', 'JUMP_ABSOLUTE', 'JUMP_FORWARD', 'CONTINUE_LOOP')
  259.     
  260.     def pruneNext(self):
  261.         
  262.         try:
  263.             (op, arg) = self.insts[-1]
  264.         except (IndexError, ValueError):
  265.             return None
  266.  
  267.         if op in self._uncond_transfer:
  268.             self.next = []
  269.         
  270.  
  271.     
  272.     def get_children(self):
  273.         if self.next and self.next[0] in self.outEdges:
  274.             self.outEdges.remove(self.next[0])
  275.         
  276.         return self.outEdges.elements() + self.next
  277.  
  278.     
  279.     def getContainedGraphs(self):
  280.         contained = []
  281.         for inst in self.insts:
  282.             if len(inst) == 1:
  283.                 continue
  284.             
  285.             op = inst[1]
  286.             if hasattr(op, 'graph'):
  287.                 contained.append(op.graph)
  288.                 continue
  289.         
  290.         return contained
  291.  
  292.  
  293. RAW = 'RAW'
  294. FLAT = 'FLAT'
  295. CONV = 'CONV'
  296. DONE = 'DONE'
  297.  
  298. class PyFlowGraph(FlowGraph):
  299.     super_init = FlowGraph.__init__
  300.     
  301.     def __init__(self, name, filename, args = (), optimized = 0, klass = None):
  302.         self.super_init()
  303.         self.name = name
  304.         self.filename = filename
  305.         self.docstring = None
  306.         self.args = args
  307.         self.argcount = getArgCount(args)
  308.         self.klass = klass
  309.         if optimized:
  310.             self.flags = CO_OPTIMIZED | CO_NEWLOCALS
  311.         else:
  312.             self.flags = 0
  313.         self.consts = []
  314.         self.names = []
  315.         self.freevars = []
  316.         self.cellvars = []
  317.         self.closure = []
  318.         if not list(args):
  319.             pass
  320.         self.varnames = []
  321.         for i in range(len(self.varnames)):
  322.             var = self.varnames[i]
  323.             if isinstance(var, TupleArg):
  324.                 self.varnames[i] = var.getName()
  325.                 continue
  326.         
  327.         self.stage = RAW
  328.  
  329.     
  330.     def setDocstring(self, doc):
  331.         self.docstring = doc
  332.  
  333.     
  334.     def setFlag(self, flag):
  335.         self.flags = self.flags | flag
  336.         if flag == CO_VARARGS:
  337.             self.argcount = self.argcount - 1
  338.         
  339.  
  340.     
  341.     def checkFlag(self, flag):
  342.         if self.flags & flag:
  343.             return 1
  344.         
  345.  
  346.     
  347.     def setFreeVars(self, names):
  348.         self.freevars = list(names)
  349.  
  350.     
  351.     def setCellVars(self, names):
  352.         self.cellvars = names
  353.  
  354.     
  355.     def getCode(self):
  356.         self.computeStackDepth()
  357.         self.flattenGraph()
  358.         self.convertArgs()
  359.         self.makeByteCode()
  360.         return self.newCodeObject()
  361.  
  362.     
  363.     def dump(self, io = None):
  364.         if io:
  365.             save = sys.stdout
  366.             sys.stdout = io
  367.         
  368.         pc = 0
  369.         for t in self.insts:
  370.             opname = t[0]
  371.             if opname == 'SET_LINENO':
  372.                 print 
  373.             
  374.             if len(t) == 1:
  375.                 print '\t', '%3d' % pc, opname
  376.                 pc = pc + 1
  377.                 continue
  378.             print '\t', '%3d' % pc, opname, t[1]
  379.             pc = pc + 3
  380.         
  381.         if io:
  382.             sys.stdout = save
  383.         
  384.  
  385.     
  386.     def computeStackDepth(self):
  387.         depth = { }
  388.         exit = None
  389.         for b in self.getBlocks():
  390.             depth[b] = findDepth(b.getInstructions())
  391.         
  392.         seen = { }
  393.         
  394.         def max_depth(b, d):
  395.             if seen.has_key(b):
  396.                 return d
  397.             
  398.             seen[b] = 1
  399.             d = d + depth[b]
  400.             children = b.get_children()
  401.             if children:
  402.                 return []([ max_depth(c, d) for c in children ])
  403.             elif not b.label == 'exit':
  404.                 return max_depth(self.exit, d)
  405.             else:
  406.                 return d
  407.  
  408.         self.stacksize = max_depth(self.entry, 0)
  409.  
  410.     
  411.     def flattenGraph(self):
  412.         self.insts = insts = []
  413.         pc = 0
  414.         begin = { }
  415.         end = { }
  416.         for b in self.getBlocksInOrder():
  417.             begin[b] = pc
  418.             for inst in b.getInstructions():
  419.                 insts.append(inst)
  420.                 if len(inst) == 1:
  421.                     pc = pc + 1
  422.                     continue
  423.                 if inst[0] != 'SET_LINENO':
  424.                     pc = pc + 3
  425.                     continue
  426.             
  427.             end[b] = pc
  428.         
  429.         pc = 0
  430.         for i in range(len(insts)):
  431.             inst = insts[i]
  432.             if len(inst) == 1:
  433.                 pc = pc + 1
  434.             elif inst[0] != 'SET_LINENO':
  435.                 pc = pc + 3
  436.             
  437.             opname = inst[0]
  438.             if self.hasjrel.has_elt(opname):
  439.                 oparg = inst[1]
  440.                 offset = begin[oparg] - pc
  441.                 insts[i] = (opname, offset)
  442.                 continue
  443.             if self.hasjabs.has_elt(opname):
  444.                 insts[i] = (opname, begin[inst[1]])
  445.                 continue
  446.         
  447.         self.stage = FLAT
  448.  
  449.     hasjrel = misc.Set()
  450.     for i in dis.hasjrel:
  451.         hasjrel.add(dis.opname[i])
  452.     
  453.     hasjabs = misc.Set()
  454.     for i in dis.hasjabs:
  455.         hasjabs.add(dis.opname[i])
  456.     
  457.     
  458.     def convertArgs(self):
  459.         self.consts.insert(0, self.docstring)
  460.         self.sort_cellvars()
  461.         for i in range(len(self.insts)):
  462.             t = self.insts[i]
  463.             if len(t) == 2:
  464.                 (opname, oparg) = t
  465.                 conv = self._converters.get(opname, None)
  466.                 if conv:
  467.                     self.insts[i] = (opname, conv(self, oparg))
  468.                 
  469.             conv
  470.         
  471.         self.stage = CONV
  472.  
  473.     
  474.     def sort_cellvars(self):
  475.         cells = { }
  476.         for name in self.cellvars:
  477.             cells[name] = 1
  478.         
  479.         self.cellvars = _[1]
  480.         for name in self.cellvars:
  481.             del cells[name]
  482.         
  483.         self.cellvars = self.cellvars + cells.keys()
  484.         self.closure = self.cellvars + self.freevars
  485.  
  486.     
  487.     def _lookupName(self, name, list):
  488.         t = type(name)
  489.         for i in range(len(list)):
  490.             if t == type(list[i]) and list[i] == name:
  491.                 return i
  492.                 continue
  493.         
  494.         end = len(list)
  495.         list.append(name)
  496.         return end
  497.  
  498.     _converters = { }
  499.     
  500.     def _convert_LOAD_CONST(self, arg):
  501.         if hasattr(arg, 'getCode'):
  502.             arg = arg.getCode()
  503.         
  504.         return self._lookupName(arg, self.consts)
  505.  
  506.     
  507.     def _convert_LOAD_FAST(self, arg):
  508.         self._lookupName(arg, self.names)
  509.         return self._lookupName(arg, self.varnames)
  510.  
  511.     _convert_STORE_FAST = _convert_LOAD_FAST
  512.     _convert_DELETE_FAST = _convert_LOAD_FAST
  513.     
  514.     def _convert_LOAD_NAME(self, arg):
  515.         if self.klass is None:
  516.             self._lookupName(arg, self.varnames)
  517.         
  518.         return self._lookupName(arg, self.names)
  519.  
  520.     
  521.     def _convert_NAME(self, arg):
  522.         if self.klass is None:
  523.             self._lookupName(arg, self.varnames)
  524.         
  525.         return self._lookupName(arg, self.names)
  526.  
  527.     _convert_STORE_NAME = _convert_NAME
  528.     _convert_DELETE_NAME = _convert_NAME
  529.     _convert_IMPORT_NAME = _convert_NAME
  530.     _convert_IMPORT_FROM = _convert_NAME
  531.     _convert_STORE_ATTR = _convert_NAME
  532.     _convert_LOAD_ATTR = _convert_NAME
  533.     _convert_DELETE_ATTR = _convert_NAME
  534.     _convert_LOAD_GLOBAL = _convert_NAME
  535.     _convert_STORE_GLOBAL = _convert_NAME
  536.     _convert_DELETE_GLOBAL = _convert_NAME
  537.     
  538.     def _convert_DEREF(self, arg):
  539.         self._lookupName(arg, self.names)
  540.         self._lookupName(arg, self.varnames)
  541.         return self._lookupName(arg, self.closure)
  542.  
  543.     _convert_LOAD_DEREF = _convert_DEREF
  544.     _convert_STORE_DEREF = _convert_DEREF
  545.     
  546.     def _convert_LOAD_CLOSURE(self, arg):
  547.         self._lookupName(arg, self.varnames)
  548.         return self._lookupName(arg, self.closure)
  549.  
  550.     _cmp = list(dis.cmp_op)
  551.     
  552.     def _convert_COMPARE_OP(self, arg):
  553.         return self._cmp.index(arg)
  554.  
  555.     for name, obj in locals().items():
  556.         if name[:9] == '_convert_':
  557.             opname = name[9:]
  558.             _converters[opname] = obj
  559.             continue
  560.     
  561.     del name
  562.     del obj
  563.     del opname
  564.     
  565.     def makeByteCode(self):
  566.         self.lnotab = lnotab = LineAddrTable()
  567.         for t in self.insts:
  568.             opname = t[0]
  569.             if len(t) == 1:
  570.                 lnotab.addCode(self.opnum[opname])
  571.                 continue
  572.             oparg = t[1]
  573.             if opname == 'SET_LINENO':
  574.                 lnotab.nextLine(oparg)
  575.                 continue
  576.             
  577.             (hi, lo) = twobyte(oparg)
  578.             
  579.             try:
  580.                 lnotab.addCode(self.opnum[opname], lo, hi)
  581.             continue
  582.             except ValueError:
  583.                 print opname, oparg
  584.                 print self.opnum[opname], lo, hi
  585.                 raise 
  586.                 continue
  587.             
  588.  
  589.         
  590.         self.stage = DONE
  591.  
  592.     opnum = { }
  593.     for num in range(len(dis.opname)):
  594.         opnum[dis.opname[num]] = num
  595.     
  596.     del num
  597.     
  598.     def newCodeObject(self):
  599.         if self.flags & CO_NEWLOCALS == 0:
  600.             nlocals = 0
  601.         else:
  602.             nlocals = len(self.varnames)
  603.         argcount = self.argcount
  604.         if self.flags & CO_VARKEYWORDS:
  605.             argcount = argcount - 1
  606.         
  607.         return new.code(argcount, nlocals, self.stacksize, self.flags, self.lnotab.getCode(), self.getConsts(), tuple(self.names), tuple(self.varnames), self.filename, self.name, self.lnotab.firstline, self.lnotab.getTable(), tuple(self.freevars), tuple(self.cellvars))
  608.  
  609.     
  610.     def getConsts(self):
  611.         l = []
  612.         for elt in self.consts:
  613.             if isinstance(elt, PyFlowGraph):
  614.                 elt = elt.getCode()
  615.             
  616.             l.append(elt)
  617.         
  618.         return tuple(l)
  619.  
  620.  
  621.  
  622. def isJump(opname):
  623.     if opname[:4] == 'JUMP':
  624.         return 1
  625.     
  626.  
  627.  
  628. class TupleArg:
  629.     
  630.     def __init__(self, count, names):
  631.         self.count = count
  632.         self.names = names
  633.  
  634.     
  635.     def __repr__(self):
  636.         return 'TupleArg(%s, %s)' % (self.count, self.names)
  637.  
  638.     
  639.     def getName(self):
  640.         return '.%d' % self.count
  641.  
  642.  
  643.  
  644. def getArgCount(args):
  645.     argcount = len(args)
  646.     if args:
  647.         for arg in args:
  648.             if isinstance(arg, TupleArg):
  649.                 numNames = len(misc.flatten(arg.names))
  650.                 argcount = argcount - numNames
  651.                 continue
  652.         
  653.     
  654.     return argcount
  655.  
  656.  
  657. def twobyte(val):
  658.     return divmod(val, 256)
  659.  
  660.  
  661. class LineAddrTable:
  662.     
  663.     def __init__(self):
  664.         self.code = []
  665.         self.codeOffset = 0
  666.         self.firstline = 0
  667.         self.lastline = 0
  668.         self.lastoff = 0
  669.         self.lnotab = []
  670.  
  671.     
  672.     def addCode(self, *args):
  673.         for arg in args:
  674.             self.code.append(chr(arg))
  675.         
  676.         self.codeOffset = self.codeOffset + len(args)
  677.  
  678.     
  679.     def nextLine(self, lineno):
  680.         if self.firstline == 0:
  681.             self.firstline = lineno
  682.             self.lastline = lineno
  683.         else:
  684.             addr = self.codeOffset - self.lastoff
  685.             line = lineno - self.lastline
  686.             if line >= 0:
  687.                 push = self.lnotab.append
  688.                 while addr > 255:
  689.                     push(255)
  690.                     push(0)
  691.                     addr -= 255
  692.                 while line > 255:
  693.                     push(addr)
  694.                     push(255)
  695.                     line -= 255
  696.                     addr = 0
  697.                 if addr > 0 or line > 0:
  698.                     push(addr)
  699.                     push(line)
  700.                 
  701.                 self.lastline = lineno
  702.                 self.lastoff = self.codeOffset
  703.             
  704.  
  705.     
  706.     def getCode(self):
  707.         return ''.join(self.code)
  708.  
  709.     
  710.     def getTable(self):
  711.         return ''.join(map(chr, self.lnotab))
  712.  
  713.  
  714.  
  715. class StackDepthTracker:
  716.     
  717.     def findDepth(self, insts, debug = 0):
  718.         depth = 0
  719.         maxDepth = 0
  720.         for i in insts:
  721.             opname = i[0]
  722.             if debug:
  723.                 print i,
  724.             
  725.             delta = self.effect.get(opname, None)
  726.             if delta is not None:
  727.                 depth = depth + delta
  728.             else:
  729.                 for pat, pat_delta in self.patterns:
  730.                     if opname[:len(pat)] == pat:
  731.                         delta = pat_delta
  732.                         depth = depth + delta
  733.                         break
  734.                         continue
  735.                 
  736.                 if delta is None:
  737.                     meth = getattr(self, opname, None)
  738.                     if meth is not None:
  739.                         depth = depth + meth(i[1])
  740.                     
  741.                 
  742.             if depth > maxDepth:
  743.                 maxDepth = depth
  744.             
  745.             if debug:
  746.                 print depth, maxDepth
  747.                 continue
  748.         
  749.         return maxDepth
  750.  
  751.     effect = {
  752.         'POP_TOP': -1,
  753.         'DUP_TOP': 1,
  754.         'LIST_APPEND': -2,
  755.         'SLICE+1': -1,
  756.         'SLICE+2': -1,
  757.         'SLICE+3': -2,
  758.         'STORE_SLICE+0': -1,
  759.         'STORE_SLICE+1': -2,
  760.         'STORE_SLICE+2': -2,
  761.         'STORE_SLICE+3': -3,
  762.         'DELETE_SLICE+0': -1,
  763.         'DELETE_SLICE+1': -2,
  764.         'DELETE_SLICE+2': -2,
  765.         'DELETE_SLICE+3': -3,
  766.         'STORE_SUBSCR': -3,
  767.         'DELETE_SUBSCR': -2,
  768.         'PRINT_ITEM': -1,
  769.         'RETURN_VALUE': -1,
  770.         'YIELD_VALUE': -1,
  771.         'EXEC_STMT': -3,
  772.         'BUILD_CLASS': -2,
  773.         'STORE_NAME': -1,
  774.         'STORE_ATTR': -2,
  775.         'DELETE_ATTR': -1,
  776.         'STORE_GLOBAL': -1,
  777.         'BUILD_MAP': 1,
  778.         'COMPARE_OP': -1,
  779.         'STORE_FAST': -1,
  780.         'IMPORT_STAR': -1,
  781.         'IMPORT_NAME': -1,
  782.         'IMPORT_FROM': 1,
  783.         'LOAD_ATTR': 0,
  784.         'SETUP_EXCEPT': 3,
  785.         'SETUP_FINALLY': 3,
  786.         'FOR_ITER': 1,
  787.         'WITH_CLEANUP': -1 }
  788.     patterns = [
  789.         ('BINARY_', -1),
  790.         ('LOAD_', 1)]
  791.     
  792.     def UNPACK_SEQUENCE(self, count):
  793.         return count - 1
  794.  
  795.     
  796.     def BUILD_TUPLE(self, count):
  797.         return -count + 1
  798.  
  799.     
  800.     def BUILD_LIST(self, count):
  801.         return -count + 1
  802.  
  803.     
  804.     def CALL_FUNCTION(self, argc):
  805.         (hi, lo) = divmod(argc, 256)
  806.         return -(lo + hi * 2)
  807.  
  808.     
  809.     def CALL_FUNCTION_VAR(self, argc):
  810.         return self.CALL_FUNCTION(argc) - 1
  811.  
  812.     
  813.     def CALL_FUNCTION_KW(self, argc):
  814.         return self.CALL_FUNCTION(argc) - 1
  815.  
  816.     
  817.     def CALL_FUNCTION_VAR_KW(self, argc):
  818.         return self.CALL_FUNCTION(argc) - 2
  819.  
  820.     
  821.     def MAKE_FUNCTION(self, argc):
  822.         return -argc
  823.  
  824.     
  825.     def MAKE_CLOSURE(self, argc):
  826.         return -argc
  827.  
  828.     
  829.     def BUILD_SLICE(self, argc):
  830.         if argc == 2:
  831.             return -1
  832.         elif argc == 3:
  833.             return -2
  834.         
  835.  
  836.     
  837.     def DUP_TOPX(self, argc):
  838.         return argc
  839.  
  840.  
  841. findDepth = StackDepthTracker().findDepth
  842.